/**
 * @(#)GruppenkalenderVerwaltung.java
 * 1.0, 2013-01-24
 */
package de.hdm.gruppenkalender.team04;

import de.hdm.gruppenkalender.team04.data.Alarm;
import de.hdm.gruppenkalender.team04.data.Kalender;
import de.hdm.gruppenkalender.team04.data.Kategorie;
import de.hdm.gruppenkalender.team04.data.Person;
import de.hdm.gruppenkalender.team04.data.Termin;
import de.hdm.gruppenkalender.team04.report.BerichtGenerator;
import java.rmi.Remote;
import java.rmi.RemoteException;
import java.sql.Timestamp;
import java.util.Vector;

/**
 * Schnittstelle zur Verwaltung von Gruppenkalendern.
 * <p>
 * Beinhaltet die Logik der kompletten Applikation.
 *
 * @author Mathias Bendel (mb167)
 * @author Björn Fichnter (bf023)
 * @author Stefan Hettich (sh176)
 * @author René Kugel (rk044)
 * @author Mark Leonberger (ml072)
 * @author Marta Przybylski (mp070)
 *
 * @version 1.0, 2013-01-24
 *
 * @see GruppenkalenderVerwaltungImpl
 *
 */
// <editor-fold defaultstate="collapsed" desc=" UML Marker "> 
// #[regen=yes,id=DCE.64B7F467-6AF4-C7B4-9E1E-79A8A6CD12FC]
// </editor-fold> 
public interface GruppenkalenderVerwaltung extends Remote {

    /**
     * Gibt den Bericht-Generator der Verwaltung zurück.
     *
     * @return  berichtGenerator
     */
    public BerichtGenerator getBerichtGenerator() throws RemoteException;

    /**
     * Setzt den Bericht-Generator der Verwaltung.
     * 
     * @param   berichtGenerator der gesetzt werden soll.
     */
    public void setBerichtGenerator(BerichtGenerator berichtGenerator) throws
            RemoteException;

    // <editor-fold defaultstate="collapsed" desc=" UML Marker "> 
    // #[regen=yes,id=DCE.CC5501BC-03A2-FF70-BC3E-BFE086E2DEA6]
    // </editor-fold>
    /**
     * Methode, um eine Person zu erstellen.
     *
     * Es wird ein neues Personen-Objekt angelegt,
     * dem entsprechende Attributwerte und eine ID  zugewiesen werden.
     *
     * Daraufhin wird das - mit Hilfe der in der PersonMapper-Klasse
     * implementierten Methode einfuegen abgelegt.
     *
     * @param   vorname     Vorname
     * @param   nachname    Nachname
     * @param   raum        Raum
     * @param   telefon     Telefon-Nummer
     * @param   email       Email-Adresse
     * @return  Person      die abgelegte Person
     * @throws  RemoteException
     */
    public Person erstellePerson(String vorname, String nachname, String raum,
            String telefon, String email) throws RemoteException;

    // <editor-fold defaultstate="collapsed" desc=" UML Marker "> 
    // #[regen=yes,id=DCE.B0A5CF15-4EE9-1091-C0E4-922982E01FB5]
    // </editor-fold>
    /**
     * Methode, um einen Kalender zu erstellen.
     *
     * Es wird ein neues Kalender-Objekt angelegt,
     * dem entsprechende Attributwerte und eine ID zugewiesen werden.
     *
     * Daraufhin wird das Kalender-Objekt mit Hilfe der in der
     * KalenderMapper-Klasse implementierten Methode einfuegen abgelegt.
     *
     * @param   bezeichnung
     * @param   besitzerId
     * @param   zugriffsberechtigteId
     * @return  Kalender                der erstellte Kalender
     * @throws  RemoteException
     */
    public Kalender erstelleKalender(String bezeichnung, int besitzerId,
            Vector<Integer> zugriffsberechtigteId) throws RemoteException;

    // <editor-fold defaultstate="collapsed" desc=" UML Marker "> 
    // #[regen=yes,id=DCE.031E1F86-62AC-B2A7-4BD6-8B2A560F72FF]
    // </editor-fold>
    /**
     * Methode, um eine Kategorie zu erstellen.
     *
     * Es wird ein neues Kategorie-Objekt angelegt,
     * dem der Name und eine ID zugewiesen werden.
     *
     * Daraufhin wird das Kategorie-Objekt mit Hilfe der in der
     * KategorieMapper-Klasse implementierten Methode einfuegen abgelegt.
     *
     * @param   name        Name
     * @return  Kategorie   die abgelegte Kategorie.
     * @throws  RemoteException
     */
    public Kategorie erstelleKategorie(String name) throws RemoteException;

    /**
     * Erstellt einen übergebenen Termin und ggf. einen Alarm und mehrere
     * Wiederholungen.
     *
     * @param   start                   Start-Zeitpunkt
     * @param   ende                    End-Zeitpunkt
     * @param   titel                   Titel
     * @param   ort                     Ort
     * @param   beschreibung            Beschreibung
     * @param   kategorieId             Kategorie-Id einer zugehörigen {@link Kategorie}
     * @param   erstellerId             Ersteller-Id einer zugehörigen {@link Person}
     * @param   kalenderId              Kalender-Id eines zugehörigen {@link Kalender}
     * @param   teilnehmerId            Teilnehmer-Ids zugehörigeer {@link Person}en
     * @param   alarmStart              Start-Zeitpunkt des zugehörigen {@link Alarm}
     * @param   anzahlWiederholungen    Anzahl der Wiederholungen
     * @param   abstandWiederholungen   Abstand zwischen den Wiederholungen
     * @throws  RemoteException
     */
    public void erstelleTermine(Timestamp start, Timestamp ende, String titel,
            String ort, String beschreibung, int kategorieId, int erstellerId,
            int kalenderId, Vector<Integer> teilnehmerId, Timestamp alarmStart,
            int anzahlWiederholungen, int abstandWiederholungen) throws
            RemoteException;

    // <editor-fold defaultstate="collapsed" desc=" UML Marker "> 
    // #[regen=yes,id=DCE.66625B96-7CD1-832D-A7F7-22D5EB304152]
    // </editor-fold>
    /**
     * Methode, um einen Alarm zu erstellen.
     *
     * Es wird ein neues Alarm-Objekt angelegt,
     * dem entsprechende Attributwerte zugewiesen werden.
     * Die ID wird zwecks Vererbungshierarchie vom Termin geholt.
     *
     * Daraufhin wird das Termin-Objekt mit Hilfe der in der
     * Terminmapper-Klasse implementierten Methode einfuegen abgelegt.
     *
     * @param   start             Start-Zeitpunkt
     * @param   titel             Titel
     * @param   kategorieId       Kategore-Id einer zugehörigen {@link Kategorie}
     * @param   erstellerId       Ersteller-Id einer zugehörigen {@link Person}
     * @param   kalenderId        Termin-Id eines verknüpften Folge-{@link Termin}
     * @param   gueltigFuerId     Termin-Id eines zugeordneten {@link Termin}
     * @return  Alarm            der abgelegte Alarm
     * @throws  RemoteException
     */
    public Alarm erstelleAlarm(Timestamp start, String titel, int kategorieId,
            int erstellerId, int kalenderId, int gueltigFuerId) throws
            RemoteException;

    // <editor-fold defaultstate="collapsed" desc=" UML Marker "> 
    // #[regen=yes,id=DCE.32735B62-55D7-98D2-9A0D-4441B711DC28]
    // </editor-fold>
    /**
     * Methode, um ein Personen-Objekt zu löschen.
     *
     * Es wird die PersonMapper-Klasse aufgerufen,
     * um den Datenbankeintrag löschen zu können.
     *
     * @param   person
     * @throws  RemoteException
     */
    public void loeschePerson(Person person) throws RemoteException;

    // <editor-fold defaultstate="collapsed" desc=" UML Marker "> 
    // #[regen=yes,id=DCE.D1CCC594-E3DB-3C44-F055-6F9CDC25F5E4]
    // </editor-fold>
    /**
     * Methode, um ein Kalender-Objekt zu löschen.
     *
     * Es wird die KalenderMapper-Klasse aufgerufen,
     * um den Datenbankeintrag löschen zu können.
     *
     * @param   kalender
     * @throws  RemoteException
     */
    public void loescheKalender(Kalender kalender) throws RemoteException;

    // <editor-fold defaultstate="collapsed" desc=" UML Marker "> 
    // #[regen=yes,id=DCE.85130EA1-494D-EAEB-C5B9-4B8F89B9F36F]
    // </editor-fold>
    /**
     * Methode, um ein Kategorie-Objekt zu löschen.
     *
     * Es wird die KategorieMapper-Klasse aufgerufen,
     * um den Datenbankeintrag löschen zu können.
     *
     * @param   kategorie
     * @throws  RemoteException
     */
    public void loescheKategorie(Kategorie kategorie) throws RemoteException;

    // <editor-fold defaultstate="collapsed" desc=" UML Marker "> 
    // #[regen=yes,id=DCE.6A6729D7-4625-1A7A-E166-3CF20EA11550]
    // </editor-fold>
    /**
     * Methode, um ein Termin-Objekt und ggf. dessen Wiederholungn zu löschen.
     *
     * Es wird die TerminMapper-Klasse, die Kalendereintrag-Klasse,
     * die AlarmMapper-Klasse, sowie die WiederholungMapper-Klasse aufgerufen,
     * um den Datenbankeintrag löschen zu können.
     *
     * @param termin            {@link Termin} der gelöscht werden soll
     * @param nutzer            {@link Person} die diesen Termin löschen möchte
     * @param allesLoeschen     Entscheidung, ob alle Termine, oder nur dieser Termin gelöscht werden soll.
     * @throws RemoteException
     */
    public void loescheTermin(Termin termin, Person nutzer,
            boolean allesLoeschen) throws RemoteException;

    // <editor-fold defaultstate="collapsed" desc=" UML Marker "> 
    // #[regen=yes,id=DCE.E5F0AC82-AC5D-1EFA-AD4A-D03E4A783DB4]
    // </editor-fold>
    /**
     * Methode, um ein Alarm-Objekt zu löschen.
     *
     * Es werden die TerminMapper und die Alarmmapper-Klasse aufgerufen,
     * um den Datenbankeinträge löschen zu können.
     * Bei Ersterem wir die entsprechende Termin-ID gelöscht.
     *
     * @param   alarm
     * @throws  RemoteException
     */
    public void loescheAlarm(Alarm alarm) throws RemoteException;

    // <editor-fold defaultstate="collapsed" desc=" UML Marker "> 
    // #[regen=yes,id=DCE.1169206E-E2BD-87AD-89D3-960C77AA9DD8]
    // </editor-fold>
    /**
     * Methode, um eine Person zu speichern.
     *
     * @param   person
     */
    public void speichern(Person person) throws RemoteException;

    // <editor-fold defaultstate="collapsed" desc=" UML Marker "> 
    // #[regen=yes,id=DCE.83055E76-E1F4-7C80-9CF7-36ED3CA6C4B9]
    // </editor-fold>
    /**
     * Methode, um ein Kalender zu speichern.
     *
     * @param   kalender
     */
    public void speichern(Kalender kalender) throws RemoteException;

    // <editor-fold defaultstate="collapsed" desc=" UML Marker "> 
    // #[regen=yes,id=DCE.F8268113-A259-E691-DE65-3D1D177B2C10]
    // </editor-fold>
    /**
     * Methode, um ein Kategorie zu speichern.
     *
     * @param   kategorie
     */
    public void speichern(Kategorie kategorie) throws RemoteException;

    // <editor-fold defaultstate="collapsed" desc=" UML Marker "> 
    // #[regen=yes,id=DCE.4C7305A6-FACA-B8A9-26F6-F42BBA2F85D4]
    // </editor-fold>
    /**
     * Methode, um einen Alarm zu speichern
     *
     * @param   alarm
     */
    public void speichern(Alarm alarm) throws RemoteException;

    // <editor-fold defaultstate="collapsed" desc=" UML Marker "> 
    // #[regen=yes,id=DCE.92E16B18-6F5D-3E9D-E688-71596EF3844B]
    // </editor-fold>
    /**
     * Methode, um alle vorhandenen Personen zu ermitteln.
     *
     * Bei dieser Methode werden die entsprechenden
     * Daten ungefiltert aus der Datenbank geholt und ausgegeben.
     *
     * @return  Vector<Person>  mit allen Personen.
     */
    public Vector<Person> ermittleAllePersonen() throws RemoteException;

    /**
     * Ermittelt eine Person anhand der übergebenen id.
     *
     * @param   id
     * @return  Person
     * @throws  RemoteException
     */
    public Person ermittlePersonViaSchluessel(int id) throws RemoteException;

    // <editor-fold defaultstate="collapsed" desc=" UML Marker "> 
    // #[regen=yes,id=DCE.1FC1B4F8-2653-A8BF-E118-7F72DB213CC3]
    // </editor-fold>
    /**
     * Methode, um alle vorhandenen Kalender zu ermitteln.
     *
     * Bei dieser Methode werden die entsprechenden
     * Daten ungefiltert aus der Datenbank geholt und ausgegeben.
     *
     * @return  Vector<Kalender>    mit allen Kalendern.
     */
    public Vector<Kalender> ermitlleAlleKalender() throws RemoteException;

    // <editor-fold defaultstate="collapsed" desc=" UML Marker "> 
    // #[regen=yes,id=DCE.45B32CD9-7A2C-1E56-2222-DE143A39E1C3]
    // </editor-fold>
    /**
     * Methode, um alle vorhandenen Termine von Person X zu ermitteln.
     * Bei dieser Methode werden personenspezifische Daten
     * aus der Datenbank geholt und ausgegeben.
     *
     * @param   person
     * @return  Vector<Kalender>    mit allen Kalendern von Person
     */
    public Vector<Kalender> ermittleAlleKalenderVonPerson(Person person) throws
            RemoteException;

    /**
     * Ermittelt die Kalender anhand einer übergebener id.
     *
     * @param   id
     * @return  Kalender mit übergebener id.
     */
    public Kalender ermittleKalenderViaSchluessel(int id) throws RemoteException;

    // <editor-fold defaultstate="collapsed" desc=" UML Marker "> 
    // #[regen=yes,id=DCE.505FBE0D-0503-1AD6-8F12-29E046F2B996]
    // </editor-fold>
    /**
     * Methode, um alle vorhandenen Kategorien zu ermitteln.
     *
     * Bei dieser Methode werden ungefilterte
     * Daten aus der Datenbank geholt und ausgegeben.
     *
     * @return  Vector<Kategorie>   mit allen Kategorien
     */
    public Vector<Kategorie> ermittleAlleKategorien() throws RemoteException;

    /**
     * Ermittelt die Kategorie anhand einer übergebenen id.
     *
     * @param   id
     * @return  Kategorie mit übergebener id.
     * @throws  RemoteException
     */
    public Kategorie ermittleKategorieViaSchluessel(int id)
            throws RemoteException;

    // <editor-fold defaultstate="collapsed" desc=" UML Marker "> 
    // #[regen=yes,id=DCE.CEF5684F-5D05-F152-A36A-860CAACEB226]
    // </editor-fold>
    /**
     * Methode, um alle vorhandenen Termine zu ermitteln.
     *
     * Bei dieser Methode werden ungefilterte
     * Daten aus der Datenbank geholt und ausgegeben.
     *
     * @return Vector<Termin> mit allen Terminen.
     */
    public Vector<Termin> ermittleAlleTermine() throws RemoteException;

    // <editor-fold defaultstate="collapsed" desc=" UML Marker "> 
    // #[regen=yes,id=DCE.BAD53021-8F1C-8D69-A663-6E40B2C36E62]
    // </editor-fold>
    /**
     * Methode, um alle vorhandenen Termine von Person X zu ermitteln.
     * Bei dieser Methode werden personenspezifische Daten
     * aus der Datenbank geholt und ausgegeben.
     *
     * @param person
     * @return Vector<Termin> mit allen Terminen von übergebener Person
     */
    public Vector<Termin> ermittleAlleTermineVonPerson(Person person) throws
            RemoteException;

    /**
     * Ermittelt alle Termine anhand der übergebenen Parameter.
     *
     * Die Parameter dienen als Filter, die null sein können.
     * Sind die Parameter nicht null gilt Folgendes:
     *
     * Die übergebene Person muss entweder Ersteller oder
     * Teilnehmer am Termin sein.
     * Die ID des übergebenen Kalenders muss der Kalender-Id des Termins
     * entsprechen.
     * Die ID der übergebenen Kategorie muss der Kategorie-Id des Termins
     * entsprechen.
     *
     * Der Termin muss zwischen dem übergebenen von- und bis-Zeitpunkt liegen.
     *
     * @param person
     * @param kalender
     * @param kategorie
     * @param von
     * @param bis
     * @return Vector<Termin> mit allen Terminen.
     * @throws RemoteException
     */
    public Vector<Termin> ermittleAlleTerminVia(Person person, Kalender kalender,
            Kategorie kategorie, Timestamp von, Timestamp bis) throws
            RemoteException;

    /**
     * Ermittelt einen Termin anhand der übergebenen id.
     *
     * @param   id
     * @return  Termin
     * @throws  RemoteException
     */
    public Termin ermittleTerminViaSchluessel(int id) throws RemoteException;

    /**
     * Ermittelt die Termin-Id anhand einer Folgetermin-Id.
     * @param   id
     * @return  Termin
     * @throws  RemoteException
     */
    public int ermittleTerminIdViaFolgetermin(int id) throws RemoteException;

    // <editor-fold defaultstate="collapsed" desc=" UML Marker "> 
    // #[regen=yes,id=DCE.54153247-0DC3-F238-40FE-FFAAD5961C17]
    // </editor-fold>
    /**
     * Methode, um alle vorhandenen Alarme zu ermitteln.
     * Bei dieser Methode werden ungefilterte
     * Daten aus der Datenbank geholt und ausgegeben.
     *
     * @return  Vector<Alarm>   mit allen Alarmen.
     */
    public Vector<Alarm> ermittleAlleAlarme() throws RemoteException;

    /**
     * Ermittelt alle Alarme einer angegebenen Person.
     *
     * @param   person
     * @return  Vector<Alarm>       Alarme einer Person.
     * @throws  RemoteException
     */
    public Vector<Alarm> ermittleAlleAlarmeVonPerson(Person person) throws
            RemoteException;

    /**
     * Ermittelt alle Alarme anhand der übergebenen Parameter.
     *
     * Die Parameter dienen als Filter, die null sein können.
     * Sind die Parameter nicht null gilt Folgendes:
     *
     * Die übergebene Person muss entweder Ersteller des Alarms sein.
     * Die ID des übergebenen Kalenders muss der Kalender-Id des Alarms
     * entsprechen.
     * Die ID der übergebenen Kategorie muss der Kategorie-Id des Alarms
     * entsprechen.
     *
     * Der Alarm muss zwischen dem übergebenen von- und bis-Zeitpunkt liegen.
     *
     * @param person
     * @param kalender
     * @param kategorie
     * @param von
     * @param bis
     * @return Vector<Alarm> mit allen Alarmen.
     * @throws RemoteException
     */
    public Vector<Alarm> ermittleAlleAlarmeVia(Person person, Kalender kalender,
            Kategorie kategorie, Timestamp von, Timestamp bis) throws
            RemoteException;

    /**
     * Ermittelt einen Alarm anhand einer übergebenen Id.
     *
     * @param   id
     * @return  Alarm   der via Schlüssel ermittelt wurde
     * @throws  RemoteException
     */
    public Alarm ermittleAlarmViaSchluessel(int id) throws RemoteException;

    /**
     * Prüft, ob die angegebene Termin-Id eine Wiederholung ist.
     *
     * @param   id
     * @return  true oder false
     * @throws  RemoteException
     */
    public boolean istWiederholung(int id) throws RemoteException;

    /**
     * Ermittelt den Abstand zwischen den Wiederholung des übergebenen Termins.
     *
     * @param   termin
     * @return  int     Abstand zwischen den Wiederholungen.
     * @throws  RemoteException
     */
    public int ermittleAbstandWiederholung(Termin termin) throws RemoteException;

    /**
     * Ermittelt die Anzahl der Wiederholung eines übergebenen Termins.
     *
     * @param   termin
     * @return  int     Anzahl der Wiederholungen.
     * @throws  RemoteException
     */
    public int ermittleAnzahlWiederholung(Termin termin) throws RemoteException;
}
